package com.chi.thread.lock;

import com.chi.thread.thread.MyThread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author chi  2017-06-22 22:55
 **/
public class MyLock {
/**
    void lock();
        如果锁已被其他线程获取，则进行等待。
    boolean tryLock();
        它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），
        则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。
    void lockInterruptibly() throws InterruptedException;
        当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。
        也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，
        那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。
     　 注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。
     　 因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。
     　 而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
**/

    private static Lock lock = new ReentrantLock();
    private static int i = 1;

    private static class MyLockThread extends Thread{
        @Override
        public void run() {
            lock.lock();
            try {
                System.out.println(i++);
                //Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args){
        for(int i=0; i< 100; i++){
            new MyLockThread().start();
        }
    }
}
